import { post, get } from '../utils/request'
import axios from "axios";
import {serverURL} from "../utils/tools";
const headers = {
  'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'
}
// 查询所有定时消息模板
export const timedMsgListAPI = () => {
  return post('/admin/message/timingMsgTemplate/selectAll')
}
// 新增定时消息模板
export const timedMsgAddAPI = (data) => {
  return post('/admin/message/timingMsgTemplate/insert', data)
}
// 更新定时消息模板
export const timedMsgEditAPI = (data) => {
  return post('/admin/message/timingMsgTemplate/updateById', data)
}
// 删除定时消息模板
export const timedMsgDelAPI = (id) => {
  return post(
    '/admin/message/timingMsgTemplate/deleteById',
    { id },
    { headers }
  )
}
// 获取定时任务列表
export const timedMsgTaskListAPI = (data) => {
  return post('/admin/message/timingMsgTask/getTaskList', data)
}
// 新增定时任务
export const timedMsgTaskAddAPI = (data) => {
  return post('/admin/message/timingMsgTask/insert', data)
}

// 触发消息模板列表
export const triggerMsgListAPI = (data) => {
  return post('/admin/message/triggerMsgTemplate/selectAll', data)
}
// 新增触发消息模板
export const triggerMsgAddAPI = (data) => {
  return post('/admin/message/triggerMsgTemplate/insert', data)
}
// 更新触发消息模板
export const triggerMsgEditAPI = (data) => {
  return post('/admin/message/triggerMsgTemplate/updateById', data)
}
// 删除触发消息模板
export const triggerMsgDelAPI = (id) => {
  return post(
    '/admin/message/triggerMsgTemplate/deleteById',
    { id },
    { headers }
  )
}
// 获取动态字段列表
export const msgFieldAPI = () => {
  return get('/admin/message/dynamicMsgFields/selectAll')
}
// 获取所有触发消息
export const triggerMsgAPI = () => {
  return post('/message/selectAll')
}
// 流式AI服务API - 增强版本
// 改进的流式AI服务API
export const aiServiceStreamAPI = (message, onData, onError, onComplete) => {
    try {
        if (!message || !onData || !onError) {
            throw new Error('缺少必要参数');
        }

        const timestamp = Date.now();
        const url = `${serverURL}/ai/bailian/agent/stream?message=${encodeURIComponent(message)}&_t=${timestamp}`;

        console.log('连接到AI服务:', url);

        let isCompleted = false;
        let eventSource = null;
        let accumulatedContent = '';
        let lastChunkTime = Date.now();
        let dataReceived = false;

        const connect = () => {
            try {
                eventSource = new EventSource(url, { withCredentials: false });

                eventSource.onmessage = (event) => {
                    try {
                        lastChunkTime = Date.now();
                        let chunk = event.data;

                        // 检查是否是SSE格式的数据
                        if (chunk.startsWith('data: ')) {
                            chunk = chunk.substring(6).trim();
                        }

                        if (!chunk) {
                            return;
                        }

                        // 标记已收到数据
                        dataReceived = true;

                        // 检查错误标记
                        if (chunk.startsWith('[ERROR]')) {
                            console.error('服务端错误:', chunk);
                            onError(new Error(chunk.substring(7)));
                            safeClose();
                            return;
                        }

                        // 检查完成标记
                        if (chunk === '[DONE]') {
                            console.log('收到完成信号，流式响应结束');
                            isCompleted = true;
                            safeClose();
                            if (onComplete) {
                                setTimeout(() => onComplete(), 100);
                            }
                            return;
                        }

                        // 处理正常数据（恢复换行符）
                        chunk = chunk.replace(/\\n/g, '\n');
                        accumulatedContent += chunk;
                        onData(chunk);

                    } catch (parseError) {
                        console.error('解析响应数据失败:', parseError);
                        onError(new Error('解析响应数据失败'));
                        safeClose();
                    }
                };

                eventSource.onerror = (error) => {
                    console.error('EventSource错误:', error);

                    // 如果已经收到了完成信号，忽略错误
                    if (isCompleted) {
                        return;
                    }

                    // 如果从未收到过数据，可能是连接失败
                    if (!dataReceived) {
                        onError(new Error('无法连接到AI服务'));
                    } else {
                        // 已经收到过数据，可能是连接意外中断
                        onError(new Error('连接意外中断，响应可能不完整'));
                    }
                    safeClose();
                };

                eventSource.onopen = () => {
                    console.log('流式连接已建立');
                    lastChunkTime = Date.now();
                };

            } catch (error) {
                console.error('创建EventSource失败:', error);
                onError(new Error(`连接失败: ${error.message}`));
            }
        };

        // 安全关闭连接
        const safeClose = () => {
            if (eventSource) {
                try {
                    eventSource.close();
                    console.log('连接已安全关闭');
                } catch (e) {
                    console.error('关闭连接时发生错误:', e);
                }
                eventSource = null;
            }
        };

        // 超时检测 - 更智能的超时逻辑
        const timeoutId = setTimeout(() => {
            if (!isCompleted) {
                const timeSinceLastChunk = Date.now() - lastChunkTime;

                // 如果从未收到数据，报连接超时
                if (!dataReceived) {
                    console.warn('AI服务连接超时');
                    onError(new Error('连接超时，请检查网络连接'));
                }
                // 如果超过10秒没有新数据，认为响应已完成但缺少结束标记
                else if (timeSinceLastChunk > 10000) {
                    console.warn('响应超时，强制结束');
                    isCompleted = true;
                    if (onComplete) onComplete();
                }
                // 否则继续等待
                else {
                    // 重置超时检测
                    clearTimeout(timeoutId);
                    const newTimeoutId = setTimeout(() => {
                        if (!isCompleted) {
                            console.warn('最终超时，强制结束');
                            onError(new Error('响应超时'));
                            safeClose();
                        }
                    }, Math.max(10000 - timeSinceLastChunk, 1000));

                    // 存储新的timeoutId以便清理
                    timeoutIds.push(newTimeoutId);
                    return;
                }

                safeClose();
            }
        }, 30000); // 初始30秒超时

        const timeoutIds = [timeoutId];

        // 开始连接
        connect();

        // 返回清理函数
        return () => {
            timeoutIds.forEach(id => clearTimeout(id));
            isCompleted = true;
            safeClose();
        };

    } catch (error) {
        console.error('AI服务初始化错误:', error);
        onError(new Error(`系统错误: ${error.message}`));
        return () => {};
    }
};
// 智能客服流式对话
// 流式AI服务API
// export const aiServiceStreamAPI = (message) => {
//     return new Promise((resolve, reject) => {
//         try {
//             // 使用相对路径，开发服务器会代理到后端
//             const url = `${serverURL}/ai/bailian/agent/stream?message=${encodeURIComponent(message)}`;
//             const eventSource = new EventSource(url);
//
//             let fullResponse = '';
//
//             eventSource.onmessage = (event) => {
//                 try {
//                     // 后端直接返回文本内容，不需要JSON解析
//                     fullResponse += event.data;
//                     // 这里可以通过resolve(fullResponse)实现流式更新，让前端实时显示
//                     resolve(fullResponse);
//                 } catch (parseError) {
//                     console.error('解析响应数据失败:', parseError);
//                 }
//             };
//
//             eventSource.onerror = (error) => {
//                 console.error('EventSource错误:', error);
//                 eventSource.close();
//                 reject(new Error('连接失败'));
//             };
//
//             // 超时处理
//             setTimeout(() => {
//                 eventSource.close();
//                 reject(new Error('请求超时'));
//             }, 30000);
//
//         } catch (error) {
//             console.error('AI服务初始化错误:', error);
//             reject(error);
//         }
//     });
// }